home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok44.lha / Analyse3.01 / server.s < prev    next >
Text File  |  1993-08-15  |  31KB  |  947 lines
  1. ;*****************************
  2. ;*           server          *
  3. ;*           ------          *
  4. ;* ( ein Assemblercode zur   *
  5. ;*     unterstützung von     *
  6. ;*     analyse V 3.01 )      *
  7. ;*                           *
  8. ;*  Version 1.11 25.08.1989  *
  9. ;*****************************
  10.  
  11. ;*** Exec - Routinen
  12.   allocmem     =   -198
  13.   freemem      =   -210
  14.   findtask     =   -294
  15.   allocsig     =   -330
  16.   freesig      =   -336
  17.   addport      =   -354
  18.   remport      =   -360
  19.   getmsg       =   -372
  20.   replymsg     =   -378
  21.   waitport     =   -384
  22.   oopenlibrary =   -408
  23.   closelibrary =   -414
  24.  
  25. ;*** Mathffp - Funktionen
  26.   spflt        =   -036
  27.   spcmp        =   -041
  28.   sptst        =   -048
  29.   spadd        =   -066
  30.   spsub        =   -072
  31.   spmul        =   -078
  32.   spdiv        =   -084
  33.  
  34. ;*** Mathtrans - Funktionen
  35.   spatan       =   -030
  36.   spsin        =   -036
  37.   spcos        =   -042
  38.   sptan        =   -048
  39.   spsinh       =   -060
  40.   spcosh       =   -066
  41.   sptanh       =   -072
  42.   spexp        =   -078
  43.   splog        =   -084
  44.   sppow        =   -090
  45.   spsqrt       =   -096
  46.   spasin       =   -114
  47.   spacos       =   -120
  48.   splog10      =   -126
  49.  
  50. ;*** sonstige Label
  51.   execbase     =    004
  52.  
  53.   job_funktion =    000         ;Code Funktionswert berechnen
  54.   job_codegen  =    001         ;Code Ausdruck kompilieren
  55.   job_codeloe  =    002         ;Code Codespeicher freigeben
  56.   job_codeanf  =    003         ;Code Codespeicher anfordern
  57.   job_kill     =    004         ;Code server beenden
  58.   job_vnfchn   =    005         ;Code Ausdruck vereinfachen
  59.  
  60.   dstuppad     =    020         ;Offset Portadresse in Message
  61.   dstartup_ok  =    024         ;Offset Ok-Feldes   in Message
  62.  
  63.   pr_msgport   =    092
  64.   size         =   1024         ;Größe Codestruktur in Bytes
  65.  
  66.   dptr         =    020         ;Offset Knotenzeigers
  67.   dx           =    024         ;Offset x
  68.   dy           =    028         ;Offset y
  69.   dz           =    032         ;Offset z
  70.   dcode        =    036         ;Offset Codezeiger
  71.   djob         =    040         ;Offset Jobcodes
  72.   derro        =    041         ;Offset Rückmeldung
  73.   dflerg       =    042         ;Offset Ergebnisses
  74.  
  75.   dlinks       =    000         ;Offset des linken  Zeigers
  76.   drechts      =    004         ;Offset des rechten Zeigers
  77.   dinvers      =    008         ;Offset der Inversflagge
  78.   dtyp         =    009         ;Offset des Knotentypes
  79.   dop          =    010         ;Offset der Operation
  80.   dfknt        =    010         ;Offset der Funktion
  81.   dvar         =    010         ;Offset der Variablen
  82.   dfloat       =    010         ;Offset der reellen Zahl
  83.   dganz        =    010         ;Offset der ganzen  Zahl
  84.   knotenlange  =    014         ;Anzahl Bytes für einen Knoten
  85.  
  86.   fknt         =    001         ;Code für Funktionsknoten
  87.   reellknt     =    002         ;Code für Reellzahlknoten
  88.   ganzknt      =    003         ;Code für Ganzzahlknoten
  89.   varknt       =    004         ;Code für Variablenknoten
  90.  
  91.   malcode      =    002         ;Code für Multiplikation
  92.   potenz       =    004         ;Code für Potentierung
  93.  
  94.   MEMF_CLEAR   = $10000         ;Code für leeren Speicher anfordern
  95.  
  96. ;*** Opcodes:
  97.   libsprung    =  $4eaa         ;Opcode für jsr     16bit    (a2)
  98.   push         =  $2f00         ;Opcode für move.l   d0   , -(sp)
  99.   pop          =  $221f         ;Opcode für move.l  (sp)+ ,   d1
  100.   movd0d1      =  $2200         ;Opcode für move.l   d0   ,   d1
  101.   expmov       =  $323c         ;Opcode für move.w #16bit ,   d1
  102.  
  103. ;*** Der Spaß geht los
  104. run:
  105.   move.l  execbase , a6
  106.   suba.l  a1 , a1               ;Zeiger auf
  107.   jsr     findtask (a6)         ;eigenen Task besorgen
  108.   move.l  d0 , a5               ;Zeiger retten
  109.  
  110.   move.l  d0 , mp_sigtask       ;Kommando Msgport init
  111.   moveq   #-1 , d0              ;nächstes freies
  112.   jsr     allocsig (a6)         ;Signalbit anfordern
  113.   move.b  d0 , mp_sigbit        ;und im Port vermerken
  114.  
  115.   lea     pr_msgport (a5) , a5  ;Addresse Msgport berechnen
  116.   move.l  a5 , a0               ;Auf die Startup - Message
  117.   jsr     waitport (a6)         ;warten
  118.   move.l  a5 , a0               ;Die Startup - Message
  119.   jsr     getmsg (a6)           ;abholen
  120.   move.l  d0 , a3               ;Zeiger auf Message
  121.   move.l  dstuppad (a3) , xarray;Adresse Variablenarray merken
  122.   move.l  #port , dstuppad (a3) ;Zeiger auf Kommandoport in Retmsg
  123.  
  124.   lea     mathtransname (pc),a1 ;Mathtrans - Library
  125.   jsr     oopenlibrary (a6)     ;öffnen
  126.   move.l  d0 , a5               ;Mathtrans - Basisadresse
  127.   move.l  d0 , mathbase         ;retten um Register zu sparen
  128.   bne.s   ok                    ;Ok. Mathtrans geöffnet
  129.  
  130. ;*** fataler Fehler: Mathtrans - Library geht nicht auf
  131. ;*** Fehler in Startup - Message schreiben und diverse
  132. ;*** Resourcen freigeben.
  133.   st      dstartup_ok (a3)      ;Fehlerflag in Startup - Msg
  134.  
  135. reterror:
  136.   clr.l   d0                    ;Langwortformat für Betr. syst.
  137.   move.b  mp_sigbit (pc) , d0   ;Signalbitnr. f. Kommandoport
  138.   jsr     freesig (a6)          ;Signalbit freigeben
  139.  
  140.   move.l  a3 , a1               ;Adresse Startup - Message
  141.   jmp     replymsg (a6)         ;antworten
  142.  
  143. ok:
  144.   lea     mathffpname (pc) , a1 ;MathFFP - Library
  145.   jsr     oopenlibrary (a6)     ;öffnen
  146.   move.l  d0 , a4
  147.   move.l  a3 , a1               ;Adresse Startup - Message
  148.   jsr     replymsg (a6)         ;antworten
  149.  
  150. ;*** Hier beginnt die Hauptschleife
  151. loop:
  152.   lea     port (pc) , a0        ;Zeiger auf Kommandoport
  153.   jsr     waitport (a6)         ;auf Auftrag warten
  154.   lea     port (pc) , a0
  155.   jsr     getmsg (a6)           ;Auftrag abholen
  156.  
  157.   move.l  d0 , a3               ;Zeiger auf Message
  158.   clr.b   derro (a3)            ;Fehlerflagge in Message
  159.   move.b  djob (a3) , d0        ;Auftragscode aus Msg holen
  160.   bne.s   examine               ;keine Fktwertberechnung
  161.  
  162. ;*** Funktionswertberechnung
  163.   movem.l dx (a3)    , d5-d7/a0 ;Variablen und Codeadresse laden
  164.   pea     (a3)                  ;Zeiger auf Message, a3 freimachen
  165.   move.l  xarray (pc) , a3      ;Zeiger auf Variablenfeld
  166.   move.l  sp         , a6       ;Stackpointer retten
  167.   lea     mylib (pc) , a2       ;Basisadresse der mylib
  168.   move.l  #$80000041 , d3       ;Fließkomma 1
  169.   jsr     (a0)                  ;Ausdruck berechnen
  170.   move.l  (sp)+ , a3            ;Zeiger auf Message restaurieren
  171.   move.l  d0 , dflerg (a3)      ;Ergebniss in Msg eintragen
  172.  
  173. retmsg:
  174.   move.l  execbase , a6         ;a6 war Rechenstackpointer
  175.  
  176. retmsg2:
  177.   move.l  a3 , a1               ;Kommandomessage
  178.   jsr     replymsg (a6)         ;zurückschicken
  179.   bra.s   loop                  ;auf nächstes Kommando warten
  180.  
  181. fwerthandler:
  182.   move.l  a6 , sp               ;Errorhandler wurde durch bra aktiv
  183.   move.l  (sp)+ , a3            ;Zeiger auf Message restaurieren
  184.   st      derro (a3)            ;Fehlerflagge in Msg setzen
  185.   bra.s   retmsg                ;und diese zurückschicken
  186.  
  187. examine:
  188.   cmp.b   #job_codegen , d0
  189.   beq.s   codegen               ;Codestruktur erzeugen
  190.   cmp.b   #job_codeloe , d0
  191.   beq.s   codeloe               ;Speicher für Code freigeben
  192.   cmp.b   #job_codeanf , d0
  193.   beq.s   codeanf               ;Speicher für Code anfordern
  194.   cmp.b   #job_kill    , d0
  195.   beq.s   kill                  ;server beenden
  196.  
  197. vnfchn:
  198.   move.l  dptr (a3) , a2        ;Zeiger auf Vaterknoten
  199.   pea     (a3)                  ;Zeiger auf Kommandomessage retten
  200.   bsr.s   winmulti              ;Ausdruck in Multibaum wandeln
  201.   bsr.s   winbin                ;Multibaum in Binärbaum wandeln
  202.   move.l  (sp)+ , a3            ;Zeiger auf Kommandomessage rückholen
  203.   move.l  a2 , dptr (a3)        ;vereinfachten Baum zurückgeben
  204.   bra.s   retmsg2
  205.  
  206. kill:
  207.   move.l  a5 , a1               ;Mathtrans - Library
  208.   jsr     closelibrary (a6)     ;schließen
  209.   move.l  a4 , a1               ;MathFFP   - Library
  210.   jsr     closelibrary (a6)     ;schließen und Prozeß beenden
  211.   bra.s   reterror              ;Message beantworten und Ende
  212.  
  213. codeanf:
  214.   move.l  #size , d0
  215.   clr.l   d1                    ;keine Anforderungen
  216.   jsr     allocmem (a6)
  217.   move.l  d0 , dcode (a3)
  218.   seq     derro (a3)            ;kein Speicher, => Fehlerflag
  219.   bra.s   retmsg2
  220.  
  221. codeloe:
  222.   move.l  #size , d0            ;Speicher freigeben
  223.   move.l  dcode (a3) , a1
  224.   jsr     freemem (a6)
  225.   bra.s   retmsg2
  226.  
  227. codegen:
  228.   move.l  dptr (a3) , a6        ;a6: Zeiger auf Wurzelknoten
  229.   move.l  dcode (a3) , a5       ;a5: Zeiger auf Codebereich
  230.   move.w  #size , d4            ;Größe des Codespeichers
  231.   move.l  sp , d3               ;retten für JMP aus Rekursion
  232.   bsr.s   coderek               ;code erzeugen
  233.   subq.w  #2 , d4               ;Ist noch Platz für ein RTS im Code ?
  234.   bcs.s   ueberlauf             ;Nein!
  235.  
  236.   move.w  #"Nu" , (a5)+         ;RTS - Code in Code schreiben
  237.  
  238. restore:
  239.   move.l  mathbase (pc) , a5    ;Die verwendeten Register restaurieren
  240.   bra.s   retmsg
  241.  
  242. ueberlauf:
  243.   move.l  d3 , sp               ;Rekursionsabbruch durch alten Stack
  244.   st      derro (a3)            ;Fehlerflagge in Kommandomessage
  245.   bra.s   restore               ;weiter mit Register restaurieren
  246.  
  247. coderek:
  248.   move.l  a6 , d0               ;Flags für Knotenzeiger
  249.   bne.s   cont
  250.   rts
  251.  
  252. cont:
  253.   move.b  dtyp (a6) , d0        ;Typ des Vaterknotens holen
  254.   cmpi.b  #reellknt , d0        ;ist es ein Terminalknoten ?
  255.   bmi.s   nichtterminal         ;nein
  256.   clr.b   d1                    ;Code erzeugen, der den Terminal-
  257.   bra.s   terminal              ;knoten nach d0 movet
  258.  
  259. nichtterminal:
  260.   tst.b   d0                    ;ist es ein Operationsknoten ?
  261.   bne.s   fknoten               ;nein. => Funktionsknoten !
  262.  
  263. ;*** Auswertung eines Operationsknotens
  264.   move.l  drechts (a6) , a0     ;Zeiger auf rechten Sohn
  265.   move.b  dtyp (a0) , d0        ;Typ des rechten Sohnes
  266.   cmpi.b  #reellknt , d0        ;ist rechter Sohn Terminalknoten ?
  267.   bmi.s   rechtsnterm           ;nein
  268.  
  269. ;*** Der rechte Sohn ist ein Terminalknoten
  270.   move.b  dop (a6) , d0         ;Operation im Vaterknoten holen
  271.   cmpi.b  #potenz  , d0         ;ist es die Potentierung ?
  272.   bne.s   notspezipot           ;nein
  273.   move.b  dtyp (a0) , d0        ;Typ des Exponenten holen
  274.   cmpi.b  #ganzknt  , d0        ;ist der Exponent ganzzahlig ?
  275.   bne.s   notspezipot           ;nein
  276.  
  277. ;*** Code fuer die spezielle Potentierung erzeugen
  278.   move.w  dganz (a0) , -(sp)    ;Exponent auf dem Stack sichern
  279.   move.l  (a6) , a6             ;Zeiger auf den linken Sohn holen
  280.   bsr.s   coderek               ;Code fuer den linken Sohn erzeugen
  281.   subq.w  #8 , d4               ;noch Platz fuer spezielle Potenzierung ?
  282.   bcs.s   ueberlauf             ;nein
  283.   move.w  #expmov , (a5)+       ;Befehl, der den Exp. nach d1 movet
  284.   move.w  (sp)+         , (a5)+ ;Exponenten als Direktoperant einfuegen
  285.   move.w  #libsprung    , (a5)+ ;Befehl zum Library - Aufruf
  286.   move.w  #5*4          , (a5)+ ;Offset fuer spezipot - Aufruf
  287.   rts
  288.  
  289. notspezipot:
  290.   pea     (a6)                  ;Adresse Vaterknoten  retten
  291.   pea     (a0)                  ;Adresse rechter Sohn retten
  292.   move.l  (a6) , a6             ;Adresse des linken Sohnes
  293.   bsr.s   coderek               ;Code für linken Sohn erzeugen
  294.   move.l  (sp)+ , a6            ;Zeiger auf den rechten Sohn
  295.   move.b  dtyp (a6) , d0        ;Typ des Terminalknotens
  296.   moveq   #1 , d1               ;Code für
  297.   bsr.s   terminal              ;Terminalknoten => d1 erzeugen
  298.   move.l  (sp)+ , a6            ;Zeiger auf Vaterknoten
  299.   bra.s   opcode                ;Code für Verknüpfung generieren
  300.  
  301. ;*** Der rechte Sohn ist kein Terminalknoten
  302. rechtsnterm:
  303.   move.l  (a6) , a1             ;Adresse des linken Sohnes
  304.   move.b  dtyp (a1) , d0        ;Typ des linken Sohnes
  305.   cmpi.b  #reellknt , d0        ;ist linker Sohn Terminalknoten
  306.   bmi.s   keintermk             ;keiner der Söhne ist ein T.knoten
  307.  
  308. ;*** Der linke Sohn ist ein Terminalknoten
  309.   pea     (a6)                  ;Adresse des Vaters retten
  310.   move.l  a0 , a6               ;Zeiger auf rechten Sohn
  311.   bsr.s   coderek               ;Code für rechten Sohn generieren
  312.   move.l  (sp) , a6             ;Adresse des Vaters zurückholen
  313.   move.b  dop (a6) , d2         ;Verknüpfung kommutativ ?
  314.   beq.s   kommutativ            ;plus ist kommutativ
  315.   cmpi.b  #malcode , d2         ;Verknüpfung 'mal'
  316.   beq.s   kommutativ            ;ist auch kommutativ
  317.  
  318. ;*** Verknüpfung im Vaterknoten ist nicht kommutativ
  319.   subq.w  #2 , d4               ;Versuch move.l d0 , d1
  320.   bcs.s   ueberlauf             ;anzuhängen
  321.  
  322.   move.w  #movd0d1 , (a5)+      ;Code erzeugen
  323.   clr.l   d1                    ;linker Terminalknoten nach d0
  324.   bra.s   vatercode             ;Code für Verknüpfung erzeugen
  325.  
  326. kommutativ:
  327.   moveq   #1 , d1               ;linken Terminalknoten nach d1
  328.  
  329. vatercode:
  330.   move.l  (a6) , a6             ;Zeiger auf linken Sohn besorgen
  331.   move.b  dtyp (a6) , d0        ;Terminalknotentyp
  332.   bsr.s   terminal
  333.   move.l  (sp)+ , a6            ;Zeiger auf Vater zurückholen
  334.   bra.s   opcode
  335.  
  336. keintermk:
  337.   pea     (a6)                  ;Zeiger auf Vaterknoten retten
  338.   move.l  drechts(a6) , a6      ;Zeiger auf rechten Sohn
  339.   bsr.s   coderek               ;Code für rechten Sohn erzeugen
  340.   subq.w  #2 , d4               ;noch Platz für ein Push ?
  341.   bcs.s   ueberlauf             ;nein !
  342.  
  343.   move.w  #push , (a5)+         ;Code für push schreiben
  344.   move.l  (sp) , a6             ;Zeiger auf Vater zurückholen
  345.   move.l  (a6) , a6             ;Zeiger linken Sohn holen
  346.   bsr.s   coderek               ;Code für linken Sohn erzeugen
  347.   subq.w  #2 , d4               ;noch Platz für Pop ?
  348.   bcs.s   ueberlauf             ;nein !
  349.  
  350.   move.w  #pop , (a5)+          ;Code für Pop schreiben
  351.   move.l  (sp)+ , a6            ;Zeiger auf Vater zurückholen
  352.  
  353. opcode:
  354.   move.b  dop (a6) , d0         ;Um welche Operation handelt es sich
  355.   subq.w  #4 , d4               ;noch Platz für Verknüpfung ?
  356.   bcs.s   ueberlauf             ;nein !
  357.  
  358.   ext.w   d0                    ;zu 16 - Bit Index machen
  359.   lsl.w   #2 , d0               ;Index in mylib
  360.   move.w  #libsprung , (a5)+    ;Sprungbefehl für mylib-Aufruf
  361.   move.w  d0 , (a5)+            ;Offset für mylib-Aufruf
  362.   rts
  363.  
  364. fknoten:
  365.   pea     (a6)                  ;Zeiger auf Vaterknoten retten
  366.   move.l  (a6) , a6             ;Zeiger auf Argument der Funktion
  367.   bsr.s   coderek               ;Code für das Argument erzeugen
  368.   move.l  (sp)+ , a6            ;Zeiger auf Vater zurückholen
  369.   subq.w  #4 , d4               ;noch Platz für Funktionsaufruf
  370.   bcs.s   ueberlauf             ;nein !
  371.  
  372.   move.b  dfknt (a6) , d0       ;Operationscode aus Knoten holen
  373.   ext.w   d0                    ;zu 16 - Bit Index machen
  374.   addq.w  #6 , d0
  375.   lsl.w   #2 , d0               ;Index in mylib
  376.   move.w  #libsprung , (a5)+    ;Sprungbefehl für mylib-Aufruf
  377.   move.w  d0 , (a5)+            ;Offset für mylib-Aufruf
  378.   rts
  379.  
  380. terminal:
  381.   tst.b   d1                    ;Tabellenbasis
  382.   bne.s   datenreg1             ;gemäß
  383.   lea     tabelle0 (pc) , a2    ;Zieldatenregister
  384.   bra.s   tabellegewaehlt
  385.  
  386. datenreg1:
  387.   lea     tabelle1 (pc) , a2    ;laden
  388.  
  389. tabellegewaehlt:
  390.   cmpi.b  #varknt , d0          ;Variable laden ?
  391.   bne.s   kvarknt               ;nein
  392.  
  393.   clr.w   d0                    ;Variablennummer auf 16 Bit
  394.   move.b  dvar (a6) , d0        ;setzen für indizierten Zugruff
  395.   cmpi.b  #253 , d0             ;x , y , z oder indizierte x Variable?
  396.   bcs.s   x_indiziert
  397.  
  398.   subq.w  #2 , d4               ;Länge Move Befehl für x , y , z
  399.   bcs.s   ueberlauf
  400.  
  401.   subi.w  #253 , d0             ;richtigen Movebefehl für x , y , z
  402.   lsl.w   #1 , d0               ;indizieren
  403.   move.w  0 (a2 , d0.w) , (a5)+ ;und in Code schreiben
  404.   rts
  405.  
  406. x_indiziert:
  407.   subq.w  #4 , d4               ;Länge des Movebefehls für indizierte
  408.   bcs.s   ueberlauf             ;Variable
  409.  
  410.   move.w  12 (a2) , (a5)+       ;Movebefehl in Code schreiben
  411.   lsl.w   #2 , d0               ;1 Variable braucht 4 Bytes
  412.   move.w  d0 , (a5)+            ;Offset für Movebefehl
  413.   rts
  414.  
  415. kvarknt:
  416.   subq.w  #6 , d4               ;Platz für Konstantenmove frei ?
  417.   bcs.s   ueberlauf             ;nein !
  418.  
  419.   move.w  6(a2) , (a5)+         ;Konstantenmovebefehl übertragen
  420.   cmpi.b  #reellknt , d0
  421.   beq.s   reellzahl             ;Reellzahlknoten
  422.  
  423. ganzzahlknoten:
  424.   move.w  dganz (a6) , d0       ;Ganzzahl aus dem Knoten holen
  425.   ext.l   d0
  426.   jsr     spflt (a4)            ;nach Fließkomma konvertieren
  427.   move.l  d0 , (a5)+            ;und als Konstante ablegen
  428.   rts
  429.  
  430. reellzahl:
  431.   move.l  dfloat (a6) , (a5)+   ;Reellzahl als Konstante ablegen
  432.   rts
  433.  
  434. tabelle0:
  435.   move.l  d5 , d0               ;x Wert in float Akku 0
  436.   move.l  d6 , d0               ;y Wert in float Akku 0
  437.   move.l  d7 , d0               ;z Wert in float Akku 0
  438.   move.l  #$12345678 , d0       ;konstante Zahl in float Akku 0
  439.   move.l  $1234 (a3) , d0       ;indizierte Variable in float Akku 0
  440.  
  441. tabelle1:
  442.   move.l  d5 , d1               ;x Wert in float Akku 1
  443.   move.l  d6 , d1               ;y Wert in float Akku 1
  444.   move.l  d7 , d1               ;z Wert in float Akku 1
  445.   move.l  #$12345678 , d1       ;konstante Zahl in float Akku 1
  446.   move.l  $1234 (a3) , d1       ;indizierte Variable in float Akku 1
  447.  
  448. mylib:
  449. ;*** operationen
  450.   bra.L   add
  451.   bra.L   sub
  452.   bra.L   mul
  453.   bra.L   div
  454.   bra.L   pow
  455.   bra.L   spezipot
  456.  
  457. ;** funktionen
  458.   bra.L   sinh
  459.   bra.L   cosh
  460.   bra.L   tanh
  461.   bra.L   coth
  462.   bra.L   arsinh
  463.   bra.L   arcosh
  464.   bra.L   artanh
  465.   bra.L   arcoth
  466.   bra.L   sin
  467.   bra.L   cos
  468.   bra.L   tan
  469.   bra.L   cot
  470.   bra.L   arcsin
  471.   bra.L   arccos
  472.   bra.L   arctan
  473.   bra.L   arccot
  474.   bra.L   exp
  475.   bra.L   ln
  476.   bra.L   log
  477.   bra.L   pot10
  478.   bra.L   wrzl
  479.   bra.L   quad
  480.  
  481. errorhandler:
  482.   move.l  handler (pc) , a0     ;jeweiligen Handler heraussuchen
  483.   jmp     (a0)                  ;und anspringen
  484.  
  485. add:
  486.   jsr     spadd  (a4)
  487.   bvs.s   errorhandler
  488.   rts
  489.  
  490. sub:
  491.   jsr     spsub  (a4)
  492.   bvs.s   errorhandler
  493.   rts
  494.  
  495. mul:
  496.   jsr     spmul  (a4)
  497.   bvs.s   errorhandler
  498.   rts
  499.  
  500. div:
  501.   tst.l   d1
  502.   beq.s   errorhandler
  503.   jsr     spdiv  (a4)
  504.   bvs.s   errorhandler
  505.   rts
  506.  
  507. pow:
  508.   jsr     sppow  (a5)
  509.   bvs.s   errorhandler
  510.   rts
  511.  
  512. sinh:
  513.   jsr     spsinh (a5)
  514.   bvs.s   errorhandler
  515.   rts
  516.  
  517. cosh:
  518.   jsr     spcosh (a5)
  519.   bvs.s   errorhandler
  520.   rts
  521.  
  522. tanh:
  523.   jsr     sptanh (a5)
  524.   bvs.s   errorhandler
  525.   rts
  526.  
  527. coth:
  528.   jsr     sptanh (a5)
  529.   tst.l   d0
  530.   beq.s   errorhandler
  531.   move.l  d0 , d1
  532.   move.l  d3 , d0
  533.   jsr     spdiv  (a4)
  534.   bvs.s   errorhandler
  535.   rts
  536.  
  537. arsinh:
  538.   move.l  d0 , d2
  539.   move.l  d0 , d1
  540.   jsr     spmul  (a4)
  541.   bvs.s   errorhandler
  542.   move.l  d3 , d1
  543.   jsr     spadd  (a4)
  544.   jsr     spsqrt (a5)
  545.   move.l  d2 , d1
  546.   jsr     spadd  (a4)
  547.   jmp     splog  (a5)
  548.  
  549. arcosh:
  550.   move.l  d0 , d2
  551.   move.l  d0 , d1
  552.   jsr     spmul  (a4)
  553.   bvs.s   errorhandler
  554.   move.l  d3 , d1
  555.   jsr     spsub  (a4)
  556.   jsr     spsqrt (a5)
  557.   bvs.s   errorhandler
  558.   move.l  d0 , d1
  559.   move.l  d2 , d0
  560.   jsr     spsub  (a4)
  561.   jsr     splog  (a5)
  562.   bvs.s   errorhandler
  563.   andi.b  #$7f , d0
  564.   rts
  565.  
  566. artanh:
  567.   move.l  d0 , d2
  568.   move.l  d3 , d1
  569.   jsr     spadd  (a4)
  570.   move.l  d0 , d4
  571.   move.l  d2 , d1
  572.   move.l  d3 , d0
  573.   jsr     spsub  (a4)
  574.   move.l  d0 , d1
  575.   beq.s   errorhandler
  576.   move.l  d4 , d0
  577.   jsr     spdiv  (a4)
  578.   jsr     splog  (a5)
  579.   bvs.s   errorhandler
  580.   move.l  #$80000042 , d1
  581.   jmp     spdiv  (a4)
  582.  
  583. arcoth:
  584.   move.l  d0 , d2
  585.   move.l  d3 , d1
  586.   jsr     spadd  (a4)
  587.   move.l  d0 , d4
  588.   move.l  d2 , d0
  589.   move.l  d3 , d1
  590.   jsr     spsub  (a4)
  591.   move.l  d0 , d1
  592.   beq.s   errorhandler
  593.   move.l  d4 , d0
  594.   jsr     spdiv  (a4)
  595.   jsr     splog  (a5)
  596.   bvs.s   errorhandler
  597.   move.l  #$80000042 , d1
  598.   jmp     spdiv  (a4)
  599.  
  600. sin:
  601.   jsr     spsin  (a5)
  602.   bvs.s   errorhandler
  603.   rts
  604.  
  605. cos:
  606.   jsr     spcos  (a5)
  607.   bvs.s   errorhandler
  608.   rts
  609.  
  610. tan:
  611.   jsr     sptan  (a5)
  612.   bvs.s   errorhandler
  613.   rts
  614.  
  615. cot:
  616.   jsr     sptan  (a5)
  617.   beq.s   errorhandler
  618.   move.l  d0 , d1
  619.   move.l  d3 , d0
  620.   jsr     spdiv  (a4)
  621.   bvs.s   errorhandler
  622.   rts
  623.  
  624. arcsin:
  625.   jsr     spasin (a5)
  626.   bvs.s   errorhandler
  627.   rts
  628.  
  629. arccos:
  630.   jsr     spacos (a5)
  631.   bvs.s   errorhandler
  632.   rts
  633.  
  634. arctan:
  635.   move.l  d0 , d2
  636.   move.l  d0 , d1
  637.   jsr     spmul  (a4)
  638.   move.l  d3 , d1
  639.   jsr     spadd  (a4)
  640.   jsr     spsqrt (a5)
  641.   move.l  d0 , d1
  642.   move.l  d2 , d0
  643.   jsr     spdiv  (a4)
  644.   jmp     spasin (a5)
  645.  
  646. arccot:
  647.   move.l  d0 , d2
  648.   move.l  d0 , d1
  649.   jsr     spmul  (a4)
  650.   move.l  d3 , d1
  651.   jsr     spadd  (a4)
  652.   jsr     spsqrt (a5)
  653.   move.l  d0 , d1
  654.   move.l  d2 , d0
  655.   jsr     spdiv  (a4)
  656.   jmp     spacos (a5)
  657.  
  658. exp:
  659.   jsr     spexp  (a5)
  660.   bvs.s   errorhandler
  661.   rts
  662.  
  663. ln:
  664.   jsr     splog  (a5)
  665.   bvs.s   errorhandler
  666.   rts
  667.  
  668. log:
  669.   tst.b   d0
  670.   bmi.s   errorhandler
  671.   jsr     splog10(a5)
  672.   rts
  673.  
  674. pot10:
  675.   move.l  d0 , d1
  676.   move.l  #$a0000044 , d0
  677.   jsr     sppow  (a5)
  678.   bvs.s   errorhandler
  679.   rts
  680.  
  681. wrzl:
  682.   jsr     spsqrt (a5)
  683.   bvs.s   errorhandler
  684.   rts
  685.  
  686. quad:
  687.   move.l  d0 , d1
  688.   jsr     spmul  (a4)
  689.   bvs.s   errorhandler
  690.   rts
  691.  
  692. spezipot:
  693.   move.l  d5 , -(sp)            ;x - Wert retten
  694.   move.w  d1 , d5               ;Exponent wird bitweise zerlegt
  695.   ext.l   d5                    ;Vorzeicheninformation retten
  696.   bpl.s   ueberhuepf            ;16 - Bit - Exponent positiv machen
  697.   neg.w   d5
  698.  
  699. ueberhuepf:
  700.   lsr.w   #1 , d5               ;Wie soll das Ergebnissfeld
  701.   bcs.s   startmitx             ;initialisiert werden ?
  702.  
  703. startmit1:
  704.   move.l  d3 , d4               ;mit einer Fliesskomma
  705.   bra.s   startpot              ;eins !
  706.  
  707. startmitx:
  708.   move.l  d0 , d4               ;mit der Basis !
  709.  
  710. startpot:
  711.   tst.w   d5                    ;noch Potenzen dazuzumultiplizieren ?
  712.   beq.s   schleifend            ;nein !
  713.   move.l  d0 , d1               ;Zwischenergebniss
  714.   jsr     spmul  (a4)           ;quadrieren
  715.   bvs.s   errorhandler
  716.   lsr.w   #1 , d5               ;Zwischenergebniss zum End-
  717.   bcc.s   startpot              ;ergebniss dazumultiplizieren ? nein !
  718.   move.l  d0 , d2               ;ja: Zwischenergebniss retten
  719.   move.l  d4 , d1               ;Zum Ergebniss
  720.   jsr     spmul  (a4)           ;dazumultiplizieren
  721.   bvs.s   errorhandler
  722.   move.l  d0 , d4               ;Ergebniss sichern
  723.   move.l  d2 , d0               ;Zwischenergebniss zurueckholen
  724.   bra.s   startpot              ;weitermachen
  725.  
  726. schleifend:
  727.   move.l  d4 , d0               ;Ergebniss immer in d0 liefern !
  728.   tst.l   d5                    ;war der Exponent negativ
  729.   bne.s   reziprok              ;ja, dann Kehrwert bilden
  730.   move.l  (sp)+ , d5            ;x - Wert zurueckschreiben
  731.   rts
  732.  
  733. reziprok:
  734.   move.l  d4 , d1               ;Ergebniss zum Nenner machen
  735.   beq.s   errorhandler          ;Division durch 0 abfangen
  736.   move.l  d3 , d0               ;Zaehler gleich 1
  737.   jsr     spdiv  (a4)           ;Kehrwert berechnen
  738.   bvs.s   errorhandler
  739.   move.l  (sp)+ , d5            ;x - Wert zurueckschreiben
  740.   rts
  741.  
  742. winmulti:
  743.   move.l  a2 , d0               ;Wurde ein leerer Baum übergeben?
  744.   beq.s   ewinmulti             ;ja => keine Aktion durchführen
  745.  
  746.   move.b  dtyp (a2) , d0        ;Typ des Vaterknotens holen
  747.   beq.s   multiopknt            ;Operationsknoten ( Verknüpfung )
  748.  
  749. multirek:
  750.   pea     (a2)                  ;Vater retten wegen postfix Rekursion
  751.   move.l  (a2) , a2             ;Zeiger auf linken Sohn stellen
  752.   bsr.s   winmulti              ;linken Sohn wandeln
  753.   move.l  (sp) , a0             ;Zeiger auf ursprünglichen Vater
  754.   move.l  a2 , (a0)+            ;linken Sohn einhängen
  755.   move.l  (a0) , a2             ;rechten Sohn auswählen
  756.   bsr.s   winmulti              ;rechten Sohn wandeln
  757.   move.l  (sp)+ , a0            ;ursprünglichen Vater rückholen
  758.   move.l  a2 , drechts (a0)     ;rechten Sohn einhängen
  759.   move.l  a0 , a2               ;Zeiger auf Vater
  760.  
  761. ewinmulti:
  762.   rts                           ;zurückgeben
  763.  
  764. multiopknt:
  765.   move.b  dop (a2) , d2         ;Verknüpfung im Vater holen
  766.   cmpi.b  #potenz , d2          ;Potenzierung?
  767.   beq.s   multirek              ;Potenzierung wird nicht gewandelt
  768.  
  769.   andi.b  #$FE , d2             ;ermitteln ob additiv, multiplikativ
  770.   move.b  d2 , -(sp)            ;retten wegen Rekursion
  771.   clr.b   d3                    ;Inversflagge zurücksetzen
  772.   suba.l  a3 , a3               ;Listenkopf leeren
  773.   bsr.s   samloplst             ;d2 : operation      d2 : Inversflag
  774.                                 ;a2 : Vater          a3 : Listenkopf
  775.   moveq   #knotenlange , d0     ;Speicher für Multiheader
  776.   move.l  #MEMF_CLEAR , d1      ;vorinitialisierten Operationsknoten
  777.   jsr     allocmem (a6)         ;anfordern
  778.   move.l  d0 , a2               ;Zugriff auf neuen Multiheader
  779.   move.b  (sp)+ , dop (a2)      ;Verknüpfung in Multiheader eintragen
  780.   move.l  a3 , (a2)             ;Operandenliste einhängen
  781.   rts
  782.  
  783. samloplst:
  784.   move.b  dtyp (a2) , d0        ;Typ des Vaterknotens holen
  785.   bne.s   nichtinvers           ;Vater ist kein Operationsknoten
  786.  
  787.   move.b  dop (a2) , d0         ;Verknüpfung im Vater holen
  788.   cmp.b   d2 , d0               ;ist es die Suchoperation?
  789.   bne.s   sonstigeop            ;nein
  790.  
  791.   pea     (a2)                  ;Zeiger auf Vaterknoten retten
  792.   move.l  (a2) , a2             ;Zeiger auf linken Sohn besorgen
  793.   bsr.s   samloplst             ;Operanden im linken Sohn einketten
  794.   move.l  (sp) , a2             ;Zeiger auf Vater
  795.   move.l  drechts (a2) , a2     ;Zeiger auf rechten Sohn besorgen
  796.   bsr.s   samloplst             ;Operanden im rechten Sohn einketten
  797.   move.l  (sp)+ , a1            ;Zeiger auf Vater
  798.   moveq   #knotenlange , d0     ;Vaterknoten freigeben und
  799.   jmp     freemem (a6)          ;Ende
  800.  
  801. sonstigeop:
  802.   eor.b   d2 , d0               ;Vater hat inverse Verknüpfung?
  803.   cmpi.b  #1 , d0
  804.   bne.s   nichtinvers           ;Nein. Andere Verknüpfung
  805.  
  806.   pea     (a2)                  ;Zeiger auf Vater retten
  807.   move.l  (a2) , a2             ;Zeiger auf linken Sohn
  808.   bsr.s   samloplst             ;Operanden im linken Sohn einketten
  809.   move.l  (sp) , a2             ;Zeiger auf Vater zurückholen
  810.   move.l  drechts (a2) , a2     ;Zeiger auf rechten Sohn besorgen
  811.   not.b   d3                    ;recht Unteroperanden sind invers
  812.   bsr.s   samloplst             ;Operanden im rechten Sohn einketten
  813.   not.b   d3                    ;Inversflagge wieder herstellen
  814.   move.l  (sp)+ , a1            ;Zeiger auf Vater zurückgewinnen
  815.   moveq   #knotenlange , d0     ;Vaterknoten freigeben und
  816.   jmp     freemem (a6)          ;Ende
  817.  
  818. nichtinvers:
  819.   pea     (a3)                  ;Listenkopf sichern
  820.   move.b  d3 , -(sp)            ;Inversflagge sichern
  821.   move.b  d2 , -(sp)            ;Verknüpfung sichern
  822.   bsr.s   winmulti
  823.   move.b  (sp)+ , d2            ;Verknüpfung  zurück
  824.   move.b  (sp)+ , d3            ;Inversflagge zurück
  825.   move.l  (sp)+ , a3            ;Listenkopf   zurück
  826.   move.l  a3 , drechts (a2)     ;Vaterknoten in Liste
  827.   move.l  a2 , a3               ;einketten
  828.   move.b  d3 , dinvers (a3)     ;Inversflagge für Vaterknoten setzen
  829.   rts
  830.  
  831. winbin:
  832.   move.l  a2 , d0               ;Wenn Zeiger gleich nil
  833.   beq.s   ewinbin2              ;dann Ende
  834.  
  835.   move.b  dtyp (a2) , d0        ;Typ des Vaterknotens
  836.   bne.s   no_opknt              ;Vater ist kein Operationsknoten
  837.  
  838.   move.b  dop (a2) , d2         ;Operation im Vaterknoten besorgen
  839.   cmpi.b  #potenz , d2          ;Potenzierung?
  840.   beq.s   no_opknt              ;liegt bereits binär vor
  841.  
  842.   move.b  d2 , -(sp)            ;lokale Variable schützen
  843.   eori.b  #1 , d2               ;inverse Operation ermitteln
  844.   move.b  d2 , -(sp)            ;lokale Variable schützen
  845.   move.l  (a2) , a3             ;Zeiger auf ersten Operanden
  846.   move.l  a2 , a0               ;Zeiger auf Zeiger auf Operanden
  847.  
  848. srchloop:
  849.   tst.b   dinvers (a3)          ;nicht inversen Knoten gefunden?
  850.   beq.s   ok_gef                ;ja
  851.  
  852.   lea     drechts (a3) , a0     ;Zeiger auf Zeiger auf nächsten Op
  853.   move.l  (a0) , a3             ;Zeiger auf nächsten Operanden
  854.   bra.s   srchloop
  855.  
  856. ok_gef:
  857.   move.l  drechts (a3) , (a0)   ;gefundenen Operanden ausketten
  858.   move.l  (a2) , drechts (a3)   ;und an erster Stelle der
  859.                                 ;Operandenliste einketten
  860.  
  861.   move.l  a2 , a1               ;Operandenheader
  862.   moveq   #knotenlange , d0     ;löschen
  863.   jsr     freemem (a6)
  864.  
  865.   move.l  a3 , a2               ;erster Operand wird neuer Vater
  866.   move.l  drechts (a3) , a3     ;Zeiger auf nächsten Operanden
  867.   clr.l   drechts (a2)          ;neuen Vater ausketten
  868.   pea     (a3)                  ;Zeiger auf nächsten Operanden retten
  869.   bsr.s   winbin
  870.   move.l  (sp)+ , a3            ;Zeiger auf nächsten Operanden
  871.  
  872. winloop:
  873.   move.l  a3 , d0               ;keine weiteren Operanden?
  874.   beq.s   ewinbin               ;nein
  875.  
  876.   moveq   #knotenlange , d0     ;neuen
  877.   move.l  #MEMF_CLEAR , d1      ;Vaterknoten
  878.   jsr     allocmem (a6)         ;anfordern
  879.   move.l  d0 , a0               ;zur Initialisierung
  880.   move.l  a2 , (a0)             ;bisheriger Vater wird linker Sohn
  881.   tst.b   dinvers (a3)          ;muß Vaterverknüpfung invers sein?
  882.   beq.s   nrmlvknt              ;nein
  883.  
  884.   move.b  (sp) , dop (a0)       ;inverse Verknüpfung im Vater
  885.   bra.s   vknset
  886.  
  887. nrmlvknt:
  888.   move.b  2(sp) , dop (a0)      ;normale Verknüpfung im Vater
  889.  
  890. vknset:
  891.   clr.b   dinvers (a3)          ;Binärbaum kennt Inversflagge nicht
  892.   pea     (a0)                  ;Zeiger auf neuen Vater retten
  893.   move.l  a3 , a2               ;Operand fertig zum wandeln machen
  894.   move.l  drechts (a3) , a3     ;nächster Operand
  895.   clr.l   drechts (a2)          ;ausketten
  896.   pea     (a3)                  ;Zeiger auf nächsten Operanden retten
  897.   bsr.s   winbin
  898.   move.l  (sp)+ , a3            ;Zeiger auf nächsten Operanden
  899.   move.l  (sp)+ , a0            ;neuer Vaterknoten
  900.   move.l  a2 , drechts (a0)     ;rechten Sohn anhängen
  901.   move.l  a0 , a2               ;neuen Vater setzen
  902.   bra.s   winloop
  903.  
  904. ewinbin:
  905.   addq.l  #4 , sp               ;lokale Variable freigeben
  906.  
  907. ewinbin2:
  908.   rts
  909.  
  910. no_opknt:
  911.   pea     (a2)                  ;Vater retten wegen postfix Rekursion
  912.   move.l  (a2) , a2             ;Zeiger auf linken Sohn stellen
  913.   bsr.s   winbin
  914.   move.l  (sp) , a0             ;Zeiger auf Vaterknoten rückgewinnen
  915.   move.l  a2 , (a0)+            ;linken Sohn einhängen
  916.   move.l  (a0) , a2             ;rechten Sohn auswählen
  917.   bsr.s   winbin                ;rechten Sohn wandeln
  918.   move.l  (sp)+ , a0            ;ursprünglichen Vater rückholen
  919.   move.l  a2 , drechts (a0)     ;rechten Sohn einhängen
  920.   move.l  a0 , a2               ;Zeiger auf Vater
  921.   rts
  922.  
  923. ;*** Port, von dem sich der server die Kommandos holt
  924. port:
  925. mp_succ:            dc.l 0
  926. mp_pred:            dc.l 0
  927. mp_type:            dc.b 4
  928. mp_pri:             dc.b 0
  929. mp_name:            dc.l 0
  930.  
  931. mp_flags:           dc.b 0
  932. mp_sigbit:          dc.b 0
  933. mp_sigtask:         dc.l 0
  934.  
  935. mp_lh_head:         dc.l mp_lh_tail
  936. mp_lh_tail:         dc.l 0
  937. mp_lh_tailpred:     dc.l mp_lh_head
  938. mp_lh_type:         dc.b 5
  939. mp_lh_pad:          dc.b 0
  940.  
  941. ;*** Weitere Datenbereiche
  942. mathbase:           dc.l 0
  943. handler:            dc.l fwerthandler
  944. xarray:             dc.l 0
  945. mathffpname:        dc.b "mathffp.library"   , 0
  946. mathtransname:      dc.b "mathtrans.library" , 0
  947.